import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import domain.LchzrzTemp;

public class ExecutorServiceTest {
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newCachedThreadPool();
		List<Future<String>> resultList = new ArrayList<Future<String>>();

		Queue<LchzrzTemp> lchzrzTemps=new ConcurrentLinkedQueue<LchzrzTemp>();
		
		Queue<String> queueList=new ConcurrentLinkedQueue<String>();
		for (int i = 0; i < 100; i++) {
			queueList.add((i+1)+"");
		}
		System.out.println("11111111111============"+queueList.size());
		// 创建10个任务并执行
		for (int i = 0; i < 10; i++) {
			// 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
			Future<String> future = executorService.submit(new TaskWithResult(i,queueList,lchzrzTemps));
			// 将任务执行结果存储到List中
			resultList.add(future);
		}
		executorService.shutdown();
		
		System.out.println("12222222222============"+queueList.size());
		
		while(true){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e){
				e.printStackTrace();
			}
			System.err.println(lchzrzTemps.size());
			if(lchzrzTemps.size()>9){
				break;
			}
		}
		
		// 遍历任务的结果
		for (Future<String> fs : resultList) {
			try {
				System.out.println(fs.get()); // 打印各个线程（任务）执行的结果
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				executorService.shutdownNow();
				e.printStackTrace();
				return;
			}
		}
	}
}

class TaskWithResult implements Callable<String> {
	private int id;
	private Queue<String> strings;
	private Queue<LchzrzTemp> lchzrzTemps;

	public TaskWithResult(int id,Queue<String> queue,Queue<LchzrzTemp> lchzrzTemps) {
		this.id = id;
		strings=queue;
		this.lchzrzTemps=lchzrzTemps;
	}

	/**
	 * 任务的具体过程，一旦任务传给ExecutorService的submit方法，则该方法自动在一个线程上执行。
	 * 
	 * @return
	 * @throws Exception
	 */
	public String call() throws Exception {
		String idString=strings.poll();
		LchzrzTemp lchzrzTemp=new LchzrzTemp(idString,"1");
		System.out.println(id+"==call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());
		//System.out.println("11"+strings.size());
//		if(id==4){
//			Thread.sleep(50*1000);
//		}
		if(lchzrzTemps.size()>=3){
			System.out.println(id+"==等待1秒:"+lchzrzTemps.size());
			Thread.sleep(id*5*1000);
			System.out.println(id+"==等待完毕");       
		}
		lchzrzTemps.offer(lchzrzTemp);
//		if (new Random().nextBoolean())
//			throw new TaskException("Meet error in task." + Thread.currentThread().getName());
//		// 一个模拟耗时的操作
//		for (int i = 999999999; i > 0; i--)
//			;
		return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();
	}
}

class TaskException extends Exception {
	public TaskException(String message) {
		super(message);
	}
}